/* 手写 String和 queue
 *
 * 1、编写类MyString的构造函数、析构函数和赋值函数
 * 2、实现一个循环队列queue
 *
 * */
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;

class MyQueue {
private:
    int *_pQue;     // 申请队列的数组空间
    int _front;     // 指示队头的位置
    int _rear;      // 指示队尾的位置
    int _size;      // 队列扩容的总大小

    void resize() {
        int *ptmp = new int[2 * _size];
        int index = 0;
        for (int i = 0; i < _rear - _front; ++i) {
            ptmp[i] = _pQue[(i + _front) % _size];
        }
        delete[] _pQue;
        _pQue = ptmp;
        _front = 0;
        _rear = _rear - _front; // 更新 _rear 为队列中实际的元素数量
        _size *= 2;
    }

public:
    MyQueue(int size = 20) {
        _pQue = new int[size];
        _front = _rear = 0;
        _size = size;
    }

    ~MyQueue() {
        delete[] _pQue;
        _pQue = nullptr;
    }

    void push(int val) {
        if (full())
            resize();
        _pQue[_rear] = val;
        _rear = (_rear + 1) % _size;
    }

    void pop() {
        if (empty())
            return;
        _front = (_front + 1) % _size;
    }

    int front() {
        return _pQue[_front];
    }

    bool full() {
        return (_rear + 1) % _size == _front;
    }

    bool empty() {
        return _front == _rear;
    }

    MyQueue(const MyQueue &src) {
        _size = src._size;
        _front = src._front;
        _rear = src._rear;
        _pQue = new int[_size];
        for (int i = 0; i < _rear - _front; ++i) {
            _pQue[i] = src._pQue[(i + _front) % _size];
        }
    }

    MyQueue &operator=(const MyQueue &src) {
        if (this == &src) {
            return *this;
        }
        delete[] _pQue;

        _size = src._size;
        _front = src._front;
        _rear = src._rear;
        _pQue = new int[_size];
        for (int i = 0; i < _rear - _front; ++i) {
            _pQue[i] = src._pQue[(i + _front) % _size];
        }
        return *this;
    }
};

int main() {
    MyQueue myQueue;
    for (int i = 0; i < 20; ++i) {
        myQueue.push(rand() % 100);
    }

    MyQueue m1 = myQueue; // 拷贝构造

    while (!myQueue.empty()) {
        cout << myQueue.front() << " ";
        myQueue.pop();
    }
    return 0;
}

/*
class MyString {
private:
    char *m_data;   // 用于保存字符串
public:
    MyString(const char *str = nullptr) {  // 普通构造函数
        if (str != nullptr) {
            m_data = new char[strlen(str) + 1];
            strcpy(m_data, str);
        } else {
            m_data = new char[1]; // 分配一个字符的空间
            *m_data = '\0'; // 设置为空字符串
        }
    }

    MyString(const MyString &other) { // 拷贝构造函数
        if (other.m_data != nullptr) {
            m_data = new char[strlen(other.m_data) + 1];
            strcpy(m_data, other.m_data);
        } else {
            m_data = new char[1]; // 分配一个字符的空间
            *m_data = '\0'; // 设置为空字符串
        }
    }

    ~MyString() {
        delete[] m_data;
        m_data = nullptr;
    }

    MyString &operator=(const MyString &other) { // 赋值重载函数
        if (this == &other) {
            return *this;
        }
        delete[] m_data;
        if (other.m_data != nullptr) {
            m_data = new char[strlen(other.m_data) + 1];
            strcpy(m_data, other.m_data);
        } else {
            m_data = new char[1]; // 分配一个字符的空间
            *m_data = '\0'; // 设置为空字符串
        }
        return *this;
    }
};

int main() {
    // 调用带 const char* 参数的构造函数
    MyString s1;
    MyString s2("hello");
    MyString s3("wyx");

    // 调用拷贝构造函数
    MyString s4 = s3;
    MyString s5(s2);

    // 调用赋值重载函数
    s1 = s2;

    return 0;
}
 */